package com.company.behavioral.interparter_pattern.context;

import com.company.behavioral.interparter_pattern.abstract_expression.AbstractNode;
import com.company.behavioral.interparter_pattern.nonterminal_expression.AndNode;
import com.company.behavioral.interparter_pattern.nonterminal_expression.SentenceNode;
import com.company.behavioral.interparter_pattern.terminal_expression.ActionNode;
import com.company.behavioral.interparter_pattern.terminal_expression.DirectionNode;
import com.company.behavioral.interparter_pattern.terminal_expression.DistanceNode;

import java.util.Stack;

/**
 * 指令处理
 * @ClassName InstructionHandler
 * @Author tiezheng.han
 * @Date 2020/9/4 10:57
 **/
public class InstructionHandler {
    private AbstractNode node;

    public void handle(String instruction){
        AbstractNode left = null,right = null;
        AbstractNode direction,action,distance;
        // 声明一个栈对象用于存储抽象语法树
        Stack<AbstractNode> stack = new Stack<>();
        //以空格分隔指令字符串
        String[] words = instruction.split(" ");
        for (int i = 0; i < words.length; i++) {
            /*
            本实例采用栈的方式处理指令，如果遇到“and”，则将其后的三个单词作为三个终结字符表达式连成一个简单的句子
            SentenceNode作为“and”的右表达式，而将从栈顶弹出的表达式作为“and”的左表达式，最后将新的“and”表达式
            压入栈中
             */
            if(words[i].equalsIgnoreCase("and")){
                //弹出栈顶表达式作为左表达式
                left = (AbstractNode)stack.pop();
                String word1 = words[++i];
                direction = new DirectionNode(word1);
                String word2 = words[++i];
                action = new ActionNode(word2);
                String word3 = words[++i];
                distance = new DistanceNode(word3);
                //右表达式
                right = new SentenceNode(direction,action,distance);
                // 将新表达式压入栈中
                stack.push(new AndNode(left,right));
            } else {
                /*
                 如果是从头开始进行解释，则将前3个单词组成一个简单句子SentencNode并将改句子压入栈中
                 */
                String word1 = words[i];
                direction = new DirectionNode(word1);
                String word2 = words[++i];
                action =  new ActionNode(word2);
                String word3 = words[++i];
                distance = new DistanceNode(word3);
                left = new SentenceNode(direction,action,distance);
                // 将新表达式压入栈中
                stack.push(left);
            }
        }
        // 全部表达式从栈中弹出
        this.node =(AbstractNode)stack.pop();
    }

    public String output(){
        //解释表达式
        String result = node.interpret();
        return result;
    }
}
